
package com.thinkgem.jeesite.common.component.redis.element;

import java.util.Map;
import java.util.Set;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.Tuple;

/** 
 * 放置rds的容器类(zset)元素操作
 * (zset可以看作是set和list的复合结构,即支持序列管理的set)
 */
public class RdsZSets {
	
	public RdsZSets(Jedis jedis) {
	    super();
	    this.jedis = jedis;
    }

	public Jedis getJedis() {
    	return jedis;
    }

	public void setJedis(Jedis jedis) {
    	this.jedis = jedis;
    }

	/**
	 * zset结构,添加指定有序的members到key中,members的序列由score确定,返回操作状态码.
	 * @param key
	 * @param score
	 * @param member
	 * @return
	 * 2014-10-28
	 */
	public Long zadd(String key,Double score,String member) {
		return getJedis().zadd(key, score, member);
	}

	/**
	 * zset结构,添加指定有序的members到key中,members的序列由score确定,返回操作状态码.
	 * (新接口,已经支持直接添加map对象)
	 * @param key
	 * @param scoreMembers
	 * @return
	 * 2014-10-28
	 */
	public Long zadd(String key,Map<String, Double> scoreMembers) {
		return getJedis().zadd(key, scoreMembers);
	}

	/**
	 * zset结构,从对应的key中删除这些members,然后返回删除成功的个数
	 * @param key
	 * @param members
	 * @return
	 * 2014-10-28
	 */
	public Long zrem(String key,String... members) {
		return getJedis().zrem(key, members);
	}

	/**
	 * zset结构,如果key中的member存在,则将他的序列增加score,否则就在key中对应的序列中重新设置一个.结果返回新序列的值.
	 * (当key中存在(1,a),(2,b),(3,c)时,如果member等于a,则在a的序列1上加上当前序列值score,从而改变a所在的位置)
	 * (通过这种方式,可以动态的改变成员在set中的位置,达到游动的效果)
	 * @param key
	 * @param score
	 * @param member
	 * @return
	 * 2014-10-28
	 */
	public Double zincrby(String key,Double score,String member) {
		return getJedis().zincrby(key, score, member);
	}

	/**
	 * zset结构,统计key中的member个数
	 * @param key
	 * @return
	 * 2014-10-28
	 */
	public Long zcard(String key) {
		return getJedis().zcard(key);
	}

	/**
	 * zset结构,返回key中member对应的score值
	 * @param key
	 * @param member
	 * @return
	 * 2014-10-28
	 */
	public Double zscore(String key,String member) {
		return getJedis().zscore(key, member);
	}

	/**
	 * zset结构,统计指定key的score在指定min和max范围内的member个数
	 * @param key
	 * @param min
	 * @param max
	 * @return
	 * 2014-10-28
	 */
	public Long zcount(String key,Double min,Double max) {
		return getJedis().zcount(key, min, max);
	}

	/**
	 * 同上,针对score是字符时的处理情况
	 * @param key
	 * @param min
	 * @param max
	 * @return
	 * 2014-10-28
	 */
	public Long zcount(String key,String min,String max) {
		return getJedis().zcount(key, min, max);
	}

	/**
	 * zset结构,统计指定key中的member名次排列
	 * @param key
	 * @param member
	 * @return
	 * 2014-10-28
	 */
	public Long zrank(String key,String member) {
		return getJedis().zrank(key, member);
	}

	/*******************检索排序:升序*********************/

	/**
	 * zset结构,按照start与end的score范围,升序排列的返回key中的members.
	 * @param key
	 * @param start
	 * @param end
	 * @return
	 * 2014-10-28
	 */
	public Set<String> zrange(String key,Long start,Long end) {
		return getJedis().zrange(key, start, end);
	}

	/**
	 * 同zrange,区别是结果集返回的是带有score的升序tuple集合(可以看作是只读的list,即score与member的向量)
	 * 而zrange仅仅返回的是score对应的member集合
	 * @param key
	 * @param start
	 * @param end
	 * @return
	 * 2014-10-28
	 */
	public Set<Tuple> zrangeWithScores(String key,Long start,Long end) {
		return getJedis().zrangeWithScores(key, start, end);
	}

	/**
	 * zset结构,按照min和max的score范围,升序排列的返回key中的members.
	 * @param key
	 * @param min
	 * @param max
	 * @return
	 * 2014-10-28
	 */
	public Set<String> zrangeByScore(String key,Double min,Double max) {
		return getJedis().zrangeByScore(key, min, max);
	}

	/**
	 * 同上,增加offset与count的结果集处理
	 * @param key
	 * @param min
	 * @param max
	 * @param offset
	 * @param count
	 * @return
	 * 2014-10-28
	 */
	public Set<String> zrangeByScore(String key,Double min,Double max,int offset,int count) {
		return getJedis().zrangeByScore(key, min, max, offset, count);
	}

	/**
	 * 同上,针对字符串的score进行检索
	 * @param key
	 * @param min
	 * @param max
	 * @return
	 * 2014-10-28
	 */
	public Set<String> zrangeByScore(String key,String min,String max) {
		return getJedis().zrangeByScore(key, min, max);
	}

	/**
	 * 同上,增加offset与count的结果集处理
	 * @param key
	 * @param min
	 * @param max
	 * @param offset
	 * @param count
	 * @return
	 * 2014-10-28
	 */
	public Set<String> zrangeByScore(String key,String min,String max,int offset,int count) {
		return getJedis().zrangeByScore(key, min, max, offset, count);
	}

	/**
	 * zset结构,按照min和max的score字母表规则,升序排列的返回key中的members.
	 * (与zrangebyscore的不同是score采用的字母进行序列管理,而不是数字)
	 * @param key
	 * @param min
	 * @param max
	 * @return
	 * 2014-10-28
	 */
//	public Set<String> zrangeByLex(String key,String min,String max) {
//		return getJedis().zrangeByLex(key, min, max);
//	}

	/**
	 * 同上,增加offset与count的结果集处理
	 * @param key
	 * @param min
	 * @param max
	 * @param offset
	 * @param count
	 * @return
	 * 2014-10-28
	 */
//	public Set<String> zrangeByLex(String key,String min,String max,int offset,int count) {
//		return getJedis().zrangeByLex(key, min, max, offset, count);
//	}

	/**
	 * 同zrangeByScore,区别是结果集返回的是带有score的升序tuple集合(可以看作是只读的list,即score与member的向量),
	 * 而zrangeByScore仅仅返回的是排序后score对应的member集合
	 * @param key
	 * @param min
	 * @param max
	 * @return
	 * 2014-10-28
	 */
	public Set<Tuple> zrangeByScoreWithScores(String key,Double min,Double max) {
		return getJedis().zrangeByScoreWithScores(key, min, max);
	}

	/**
	 * 同上,增加offset与count的结果集处理
	 * @param key
	 * @param min
	 * @param max
	 * @param offset
	 * @param count
	 * @return
	 * 2014-10-28
	 */
	public Set<Tuple> zrangeByScoreWithScores(String key,Double min,Double max,int offset,int count) {
		return getJedis().zrangeByScoreWithScores(key, min, max, offset, count);
	}

	/**
	 * 同上,针对字符串score的处理
	 * @param key
	 * @param min
	 * @param max
	 * @return
	 * 2014-10-28
	 */
	public Set<Tuple> zrangeByScoreWithScores(String key,String min,String max) {
		return getJedis().zrangeByScoreWithScores(key, min, max);
	}

	/**
	 * 同上,增加offset与count的结果集处理
	 * @param key
	 * @param min
	 * @param max
	 * @param offset
	 * @param count
	 * @return
	 * 2014-10-28
	 */
	public Set<Tuple> zrangeByScoreWithScores(String key,String min,String max,int offset,int count) {
		return getJedis().zrangeByScoreWithScores(key, min, max, offset, count);
	}

	/*******************检索排序:降序*********************/

	/**
	 * zset结构,按照start与end的score范围,降序排列的返回key中的members.
	 * @param key
	 * @param start
	 * @param end
	 * @return
	 * 2014-10-28
	 */
	public Set<String> zrevrange(String key,Long start,Long end) {
		return getJedis().zrevrange(key, start, end);
	}

	/**
	 * 同zrange,区别是结果集返回的是带有score的降序tuple集合(可以看作是只读的list,即score与member的向量)
	 * 而zrange仅仅返回的是score对应的member集合
	 * @param key
	 * @param start
	 * @param end
	 * @return
	 * 2014-10-28
	 */
	public Set<Tuple> zrevrangeWithScores(String key,Long start,Long end) {
		return getJedis().zrevrangeWithScores(key, start, end);
	}

	/**
	 * zset结构,按照min和max的score范围,降序排列的返回key中的members.
	 * @param key
	 * @param min
	 * @param max
	 * @return
	 * 2014-10-28
	 */
	public Set<String> zrevrangeByScore(String key,Double min,Double max) {
		return getJedis().zrevrangeByScore(key, min, max);
	}

	/**
	 * 同上,增加offset与count的结果集处理
	 * @param key
	 * @param min
	 * @param max
	 * @param offset
	 * @param count
	 * @return
	 * 2014-10-28
	 */
	public Set<String> zrevrangeByScore(String key,Double min,Double max,int offset,int count) {
		return getJedis().zrevrangeByScore(key, min, max, offset, count);
	}

	/**
	 * 同上,针对字符串的score进行检索
	 * @param key
	 * @param min
	 * @param max
	 * @return
	 * 2014-10-28
	 */
	public Set<String> zrevrangeByScore(String key,String min,String max) {
		return getJedis().zrevrangeByScore(key, min, max);
	}

	/**
	 * 同上,增加offset与count的结果集处理
	 * @param key
	 * @param min
	 * @param max
	 * @param offset
	 * @param count
	 * @return
	 * 2014-10-28
	 */
	public Set<String> zrevrangeByScore(String key,String min,String max,int offset,int count) {
		return getJedis().zrevrangeByScore(key, min, max, offset, count);
	}

	/**
	 * 同zrangeByScore,区别是结果集返回的是带有score的降序tuple集合(可以看作是只读的list,即score与member的向量),
	 * 而zrangeByScore仅仅返回的是排序后score对应的member集合
	 * @param key
	 * @param min
	 * @param max
	 * @return
	 * 2014-10-28
	 */
	public Set<Tuple> zrevrangeByScoreWithScores(String key,Double min,Double max) {
		return getJedis().zrevrangeByScoreWithScores(key, min, max);
	}

	/**
	 * 同上,增加offset与count的结果集处理
	 * @param key
	 * @param min
	 * @param max
	 * @param offset
	 * @param count
	 * @return
	 * 2014-10-28
	 */
	public Set<Tuple> zrevrangeByScoreWithScores(String key,Double min,Double max,int offset,int count) {
		return getJedis().zrevrangeByScoreWithScores(key, min, max, offset, count);
	}

	/**
	 * 同上,针对字符串score的处理
	 * @param key
	 * @param min
	 * @param max
	 * @return
	 * 2014-10-28
	 */
	public Set<Tuple> zrevrangeByScoreWithScores(String key,String min,String max) {
		return getJedis().zrevrangeByScoreWithScores(key, min, max);
	}

	/**
	 * 同上,增加offset与count的结果集处理
	 * @param key
	 * @param min
	 * @param max
	 * @param offset
	 * @param count
	 * @return
	 * 2014-10-28
	 */
	public Set<Tuple> zrevrangeByScoreWithScores(String key,String min,String max,int offset,int count) {
		return getJedis().zrevrangeByScoreWithScores(key, min, max, offset, count);
	}

	private Jedis jedis;//当前客户端
}
